home *** CD-ROM | disk | FTP | other *** search
/ The Java 3D API Specification (2nd Edition) / The Java 3D API Specification (2nd Edition).iso / programs / examples / FourByFour / Positions.java < prev    next >
Text File  |  2000-04-28  |  10KB  |  298 lines
  1. /*
  2.  *    @(#)Positions.java 1.9 00/02/10 13:13:53
  3.  *
  4.  * Copyright (c) 1996-2000 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
  7.  * modify and redistribute this software in source and binary code form,
  8.  * provided that i) this copyright notice and license appear on all copies of
  9.  * the software; and ii) Licensee does not utilize the software in a manner
  10.  * which is disparaging to Sun.
  11.  *
  12.  * This software is provided "AS IS," without a warranty of any kind. ALL
  13.  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
  14.  * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  15.  * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
  16.  * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
  17.  * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
  18.  * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
  19.  * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
  20.  * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
  21.  * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
  22.  * POSSIBILITY OF SUCH DAMAGES.
  23.  *
  24.  * This software is not designed or intended for use in on-line control of
  25.  * aircraft, air traffic, aircraft navigation or aircraft communications; or in
  26.  * the design, construction, operation or maintenance of any nuclear
  27.  * facility. Licensee represents and warrants that it will not use or
  28.  * redistribute the Software for such purposes.
  29.  */
  30.  
  31. import java.applet.Applet;
  32. import java.awt.event.*;
  33. import javax.media.j3d.*;
  34. import javax.vecmath.*;
  35. import java.util.BitSet;
  36. import com.sun.j3d.utils.geometry.Sphere;
  37.  
  38. /**
  39.  * Class:       Positions
  40.  *
  41.  * Description: Creates the position markers.
  42.  *
  43.  * Version:     1.0
  44.  *
  45.  */
  46. public class Positions extends Object {
  47.  
  48.    final static int UNOCCUPIED = 0;
  49.    final static int HUMAN      = 1;
  50.    final static int MACHINE    = 2;
  51.    final static int END        = 3;
  52.  
  53.    private Vector3f point[];
  54.    private Switch posSwitch;
  55.    private Switch humanSwitch;
  56.    private Switch machineSwitch;
  57.    private BitSet posMask;
  58.    private BitSet humanMask;
  59.    private BitSet machineMask;
  60.    private Group group;
  61.    private Material redMat;
  62.    private Material blueMat;
  63.    private Material yellowMat;
  64.    private Material whiteMat;
  65.    private Appearance redApp;
  66.    private Appearance blueApp;
  67.    private Appearance yellowApp;
  68.    private Appearance whiteApp;
  69.    private Board board;
  70.    private Sphere posSphere[];
  71.    private BigCube cube[];
  72.    private TransformGroup tgroup;
  73.    private boolean winnerFlag = false;
  74.  
  75.    public Positions() {
  76.  
  77.       // Define colors for lighting
  78.       Color3f white     = new Color3f(1.0f, 1.0f, 1.0f);
  79.       Color3f black     = new Color3f(0.0f, 0.0f, 0.0f);
  80.       Color3f red       = new Color3f(0.9f, 0.1f, 0.2f);
  81.       Color3f blue      = new Color3f(0.3f, 0.3f, 0.8f);
  82.       Color3f yellow    = new Color3f(1.0f, 1.0f, 0.0f);
  83.       Color3f ambRed    = new Color3f(0.3f, 0.03f, 0.03f);
  84.       Color3f ambBlue   = new Color3f(0.03f, 0.03f, 0.3f);
  85.       Color3f ambYellow = new Color3f(0.3f, 0.3f, 0.03f);
  86.       Color3f ambWhite  = new Color3f(0.3f, 0.3f, 0.3f);
  87.       Color3f specular  = new Color3f(1.0f, 1.0f, 1.0f);
  88.  
  89.       // Create the red appearance node
  90.       redMat= new Material(ambRed, black, red, specular, 100.f);
  91.       redMat.setLightingEnable(true);
  92.       redApp = new Appearance();
  93.       redApp.setMaterial(redMat);
  94.  
  95.       // Create the blue appearance node
  96.       blueMat= new Material(ambBlue, black, blue, specular, 100.f);
  97.       blueMat.setLightingEnable(true);
  98.       blueApp = new Appearance();
  99.       blueApp.setMaterial(blueMat);
  100.  
  101.       // Create the yellow appearance node
  102.       yellowMat= new Material(ambYellow, black, yellow, specular, 100.f);
  103.       yellowMat.setLightingEnable(true);
  104.       yellowApp = new Appearance();
  105.       yellowApp.setMaterial(yellowMat);
  106.  
  107.       // Create the white appearance node
  108.       whiteMat= new Material(ambWhite, black, white, specular, 100.f);
  109.       whiteMat.setLightingEnable(true);
  110.       whiteApp = new Appearance();
  111.       whiteApp.setMaterial(whiteMat);
  112.  
  113.       // Load the point array with the offset (coordinates) for each of 
  114.       // the 64 positions.
  115.       point = new Vector3f[64];
  116.       int count = 0;
  117.       for (int i=-30; i<40; i+=20) {
  118.          for (int j=-30; j<40; j+=20) {
  119.             for (int k=-30; k<40; k+=20) {
  120.                point[count] = new Vector3f((float) k, (float) j, (float) i);
  121.                count++;
  122.             }
  123.          }
  124.       }
  125.  
  126.       // Create the switch nodes
  127.       posSwitch = new Switch(Switch.CHILD_MASK);
  128.       humanSwitch = new Switch(Switch.CHILD_MASK);
  129.       machineSwitch = new Switch(Switch.CHILD_MASK);
  130.  
  131.       // Set the capability bits
  132.       posSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
  133.       posSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
  134.  
  135.       humanSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
  136.       humanSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
  137.       
  138.       machineSwitch.setCapability(Switch.ALLOW_SWITCH_READ);
  139.       machineSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
  140.       
  141.       // Create the bit masks
  142.       posMask = new BitSet();  
  143.       humanMask = new BitSet();  
  144.       machineMask = new BitSet();  
  145.  
  146.       // Create the small white spheres that mark unoccupied
  147.       // positions.
  148.       posSphere = new Sphere[64];
  149.       for (int i=0; i<64; i++) {
  150.          Transform3D transform3D = new Transform3D();
  151.          transform3D.set(point[i]);
  152.          TransformGroup transformGroup = new TransformGroup(transform3D);
  153.          posSphere[i] = new Sphere(2.0f, Sphere.GENERATE_NORMALS |
  154.                    Sphere.ENABLE_APPEARANCE_MODIFY,
  155.                    12, whiteApp);
  156.          Shape3D shape = posSphere[i].getShape(); 
  157.          ID id = new ID(i);
  158.          shape.setUserData(id); 
  159.          transformGroup.addChild(posSphere[i]);
  160.          posSwitch.addChild(transformGroup);
  161.          posMask.set(i);
  162.       }
  163.  
  164.       // Create the red spheres that mark the user's positions.
  165.       for (int i=0; i<64; i++) {
  166.          Transform3D transform3D = new Transform3D();
  167.          transform3D.set(point[i]);
  168.          TransformGroup transformGroup = new TransformGroup(transform3D);
  169.          transformGroup.addChild(new Sphere(7.0f, redApp));
  170.          humanSwitch.addChild(transformGroup);
  171.          humanMask.clear(i);
  172.       }
  173.  
  174.       // Create the blue cubes that mark the computer's positions.
  175.       for (int i=0; i<64; i++) {
  176.          Transform3D transform3D = new Transform3D();
  177.          transform3D.set(point[i]);
  178.          TransformGroup transformGroup = new TransformGroup(transform3D);
  179.          BigCube cube = new BigCube(blueApp);
  180.          transformGroup.addChild(cube.getChild());
  181.          machineSwitch.addChild(transformGroup);
  182.          machineMask.clear(i);
  183.       }
  184.  
  185.       // Set the positions mask
  186.       posSwitch.setChildMask(posMask);
  187.       humanSwitch.setChildMask(humanMask);
  188.       machineSwitch.setChildMask(machineMask);
  189.  
  190.       // Throw everything into a single group
  191.       group = new Group();
  192.       group.addChild(posSwitch);
  193.       group.addChild(humanSwitch);
  194.       group.addChild(machineSwitch);
  195.    }
  196.  
  197.    public void setTransformGroup(TransformGroup transformGroup) {
  198.       tgroup = transformGroup;
  199.    }
  200.  
  201.    public Group getChild() {
  202.       return group;
  203.    }
  204.  
  205.    public void setBoard(Board board) {
  206.       this.board = board;
  207.    }
  208.  
  209.    public void winner() {
  210.       winnerFlag = true;
  211.    }
  212.  
  213.    public void noWinner() {
  214.       winnerFlag = false;
  215.    }
  216.  
  217.    public void setHighlight(int pos) {
  218.       posSphere[pos].setAppearance(yellowApp);
  219.    }
  220.  
  221.    public void clearHighlight(int pos) {
  222.       posSphere[pos].setAppearance(whiteApp);
  223.    }
  224.  
  225.    public void newGame() {
  226.  
  227.       // Clear the board
  228.       for (int i=0; i<64; i++) {
  229.          posMask.set(i);
  230.          humanMask.clear(i);
  231.          machineMask.clear(i);
  232.       }
  233.       posSwitch.setChildMask(posMask);
  234.       humanSwitch.setChildMask(humanMask);
  235.       machineSwitch.setChildMask(machineMask);
  236.  
  237.       // The following three lines fix a bug in J3D
  238.       Transform3D t = new Transform3D();
  239.       tgroup.getTransform(t);
  240.       tgroup.setTransform(t);
  241.  
  242.       // Reset the winner flag
  243.       winnerFlag = false;
  244.    }
  245.  
  246.    public void set(int pos, int player) {
  247.  
  248.       // Stop accepting selections when the game
  249.       // is over.
  250.       if (winnerFlag) return;
  251.  
  252.       // Make sure the position is not occupied.
  253.       if (player == HUMAN)
  254.          if (!board.unoccupied(pos)) return;
  255.  
  256.       // Turn off the position marker for the given position
  257.       posMask.clear(pos);
  258.       posSwitch.setChildMask(posMask);
  259.  
  260.       // Turn on the player marker
  261.       if (player == Positions.HUMAN) {
  262.          humanMask.set(pos);
  263.          humanSwitch.setChildMask(humanMask);
  264.          board.selection(pos, Positions.HUMAN);
  265.       }
  266.       else {
  267.          machineMask.set(pos);
  268.          machineSwitch.setChildMask(machineMask);
  269.       }
  270.  
  271.       // The following three lines fix a bug in J3D
  272.       Transform3D t = new Transform3D();
  273.       tgroup.getTransform(t);
  274.       tgroup.setTransform(t);
  275.    }
  276.  
  277.    public void clear(int pos) {
  278.  
  279.       // Turn on the position marker
  280.       posMask.set(pos);
  281.       posSwitch.setChildMask(posMask);
  282.  
  283.       // Turn off the player marker
  284.       humanMask.clear(pos);
  285.       humanSwitch.setChildMask(humanMask);
  286.       machineMask.clear(pos);
  287.       machineSwitch.setChildMask(machineMask);
  288.  
  289.       // The following three lines are a workaround for a bug 
  290.       // in dev09 in which the transform3D of certain items are
  291.       // not updated properly. Scheduled to be fixed in dev10
  292.       Transform3D t = new Transform3D();
  293.       tgroup.getTransform(t);
  294.       tgroup.setTransform(t);
  295.    }
  296.  
  297. }
  298.